package com.ourteam.education.dao;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;
/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2019-09-22 15:15:08
  * Warning ! This file will be overwrite when regenerate !
  * 
 */
public class TeacherDAOQueryBean extends BaseQueryBean {
    
    public TeacherDAOQueryBean() {
		super();
    }
	
    public TeacherDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }
    
    public TeacherDAOQueryBean(BaseQueryBean aQueryBean,Map tableReplaceMap) {
        super(aQueryBean,tableReplaceMap);
    }
    
    public Criteria createCriteria() {
        
	    Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
                  oredCriteria.add(criteria);
            }
        return criteria;
     }
	
    protected Criteria createCriteriaInternal() {
	  return new Criteria(this);
    }
    
        
        
    	
		
	    
    public void addIdSelectProperty(){
		addIdSelectProperty("id");
	}
	
    public void addIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.Id,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.Id,"id");
	    }
    }
    
       
		
		
	    
    public void addTeacherNameSelectProperty(){
		addTeacherNameSelectProperty("teacherName");
	}
	
    public void addTeacherNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.TeacherName,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.TeacherName,"teacherName");
	    }
    }
    
       
		
		
	    
    public void addTeacherGenderSelectProperty(){
		addTeacherGenderSelectProperty("teacherGender");
	}
	
    public void addTeacherGenderSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.TeacherGender,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.TeacherGender,"teacherGender");
	    }
    }
    
       
		
		
	    
    public void addTeacherBirthdaySelectProperty(){
		addTeacherBirthdaySelectProperty("teacherBirthday");
	}
	
    public void addTeacherBirthdaySelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.TeacherBirthday,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.TeacherBirthday,"teacherBirthday");
	    }
    }
    
       
		
		
	    
    public void addContactPhoneSelectProperty(){
		addContactPhoneSelectProperty("contactPhone");
	}
	
    public void addContactPhoneSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.ContactPhone,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.ContactPhone,"contactPhone");
	    }
    }
    
       
		
		
	    
    public void addContactsRelationSelectProperty(){
		addContactsRelationSelectProperty("contactsRelation");
	}
	
    public void addContactsRelationSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.ContactsRelation,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.ContactsRelation,"contactsRelation");
	    }
    }
    
       
		
		
	    
    public void addIdCardTypeSelectProperty(){
		addIdCardTypeSelectProperty("idCardType");
	}
	
    public void addIdCardTypeSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.IdCardType,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.IdCardType,"idCardType");
	    }
    }
    
       
		
		
	    
    public void addIdCardNumSelectProperty(){
		addIdCardNumSelectProperty("idCardNum");
	}
	
    public void addIdCardNumSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.IdCardNum,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.IdCardNum,"idCardNum");
	    }
    }
    
       
		
		
	    
    public void addSysAccountIdSelectProperty(){
		addSysAccountIdSelectProperty("sysAccountId");
	}
	
    public void addSysAccountIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.SysAccountId,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.SysAccountId,"sysAccountId");
	    }
    }
    
       
		
		
	    
    public void addDeleteFlagSelectProperty(){
		addDeleteFlagSelectProperty("deleteFlag");
	}
	
    public void addDeleteFlagSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.DeleteFlag,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.DeleteFlag,"deleteFlag");
	    }
    }
    
       
		
		
	    
    public void addStatusSelectProperty(){
		addStatusSelectProperty("status");
	}
	
    public void addStatusSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.Status,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.Status,"status");
	    }
    }
    
       
		
		
	    
    public void addRemarksSelectProperty(){
		addRemarksSelectProperty("remarks");
	}
	
    public void addRemarksSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ITeacherDAO.Remarks,aAlias);
		}
		else{
			addSelectProperty(ITeacherDAO.Remarks,"remarks");
	    }
    }
    
       
		
		
	public void addAllSelectProperties(){
		
		
	    addIdSelectProperty();
   
		
		
	    addTeacherNameSelectProperty();
   
		
		
	    addTeacherGenderSelectProperty();
   
		
		
	    addTeacherBirthdaySelectProperty();
   
		
		
	    addContactPhoneSelectProperty();
   
		
		
	    addContactsRelationSelectProperty();
   
		
		
	    addIdCardTypeSelectProperty();
   
		
		
	    addIdCardNumSelectProperty();
   
		
		
	    addSysAccountIdSelectProperty();
   
		
		
	    addDeleteFlagSelectProperty();
   
		
		
	    addStatusSelectProperty();
   
		
		
	    addRemarksSelectProperty();
   
		
	    }
    
    public static class Criteria extends BaseWhereCriterion<TeacherDAOQueryBean> {
	
        protected Criteria(TeacherDAOQueryBean aParentObject) {
		    super(aParentObject);
        }
        
                  
            	
    	    	
    	        
                
        public Criteria andIdIsNull() {
            addCriterion(ITeacherDAO.Id + " is null");
            return this;
        }
        public Criteria andIdIsNotNull() {
            addCriterion(ITeacherDAO.Id + " is not null");
            return this;
        }
    
        public Criteria andIdIsNotEmpty() {        
            addCriterion(ITeacherDAO.Id + " is not null AND " + ITeacherDAO.Id + " <> ''");
            return this;
        }
    		
    	public Criteria andIdIsEmpty() {       
            addCriterion("(" + ITeacherDAO.Id + " is null OR " + ITeacherDAO.Id + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andIdEqualTo(long value) {
        	return andIdEqualTo(Long.valueOf(value));
        }
               public Criteria andIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.Id + " = ", value, "id");
            return this;
        }
        
        public Criteria andIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Id);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andIdNotEqualTo(long value) {
        	return andIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ITeacherDAO.Id + " <>", value, "id");
            return this;
        }
               
        public Criteria andIdNotEqualToOrIsNull(long value) {
        	return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ITeacherDAO.Id + " is null OR " + ITeacherDAO.Id + " <>", value, "id");
            return this;
        }
        
        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Id);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andIdGreaterThan(long value) {
        	return andIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.Id + " >", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Id);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andIdGreaterThanOrEqualTo(long value) {
        	return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.Id + " >=", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Id);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdLessThan(long value) {
        	return andIdLessThan(Long.valueOf(value));
        }
                public Criteria andIdLessThan(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.Id + " <", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Id);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdLessThanOrEqualTo(long value) {
        	return andIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.Id + " <=", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Id);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andIdIn(long[] values) {
        	if(values.length == 1){
        		return andIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Id + " in", values, "id");
            	return this;
            }
        }
        
        public Criteria andIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Id + " not in", values, "id");
            	return this;
            }
        }
        
                public Criteria andIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.Id + " in", values, "id");
            	return this;
            }
        }
        public Criteria andIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.Id + " not in", values, "id");
            	return this;
            }
        }
        
        public Criteria andIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Id + " in", Arrays.asList(values), "id");
            	return this;
            }
        }
        public Criteria andIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Id + " not in", Arrays.asList(values), "id");
            	return this;
            }
        }
		
		public Criteria andIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Id + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdBetween(long value1,long value2) {
        	addCriterion(ITeacherDAO.Id + " between", value1, value2, "id");
            return this;
        }
                public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ITeacherDAO.Id + " between", value1, value2, "id");
            return this;
        }
        
                
        public Criteria andIdNotBetween(long value1,long value2) {
        	addCriterion(ITeacherDAO.Id + " not between", value1, value2, "id");
            return this;
        }
                public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ITeacherDAO.Id + " not between", value1, value2, "id");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andTeacherNameIsNull() {
            addCriterion(ITeacherDAO.TeacherName + " is null");
            return this;
        }
        public Criteria andTeacherNameIsNotNull() {
            addCriterion(ITeacherDAO.TeacherName + " is not null");
            return this;
        }
    
        public Criteria andTeacherNameIsNotEmpty() {        
            addCriterion(ITeacherDAO.TeacherName + " is not null AND " + ITeacherDAO.TeacherName + " <> ''");
            return this;
        }
    		
    	public Criteria andTeacherNameIsEmpty() {       
            addCriterion("(" + ITeacherDAO.TeacherName + " is null OR " + ITeacherDAO.TeacherName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andTeacherNameEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.TeacherName + " = ", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andTeacherNameNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.TeacherName + " <>", value, "teacherName");
            return this;
        }
               
        public Criteria andTeacherNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.TeacherName + " is null OR " + ITeacherDAO.TeacherName + " <>", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherNameGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.TeacherName + " >", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.TeacherName + " >=", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherNameLessThan(String value) {
        				
            addCriterion(ITeacherDAO.TeacherName + " <", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.TeacherName + " <=", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andTeacherNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.TeacherName + " like", buffer.toString(), "teacherName");
            return this;
        }
        public Criteria andTeacherNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.TeacherName + " not like", buffer.toString(), "teacherName");
            return this;
        }
                
                public Criteria andTeacherNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andTeacherNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherName + " in", values, "teacherName");
            	return this;
            }
        }
        public Criteria andTeacherNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andTeacherNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherName + " not in", values, "teacherName");
            	return this;
            }
        }
        
        public Criteria andTeacherNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andTeacherNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherName + " in", Arrays.asList(values), "teacherName");
            	return this;
            }
        }
        public Criteria andTeacherNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andTeacherNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherName + " not in", Arrays.asList(values), "teacherName");
            	return this;
            }
        }
		
		public Criteria andTeacherNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andTeacherNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherNameBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.TeacherName + " between", value1, value2, "teacherName");
            return this;
        }
        
                public Criteria andTeacherNameNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.TeacherName + " not between", value1, value2, "teacherName");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andTeacherGenderIsNull() {
            addCriterion(ITeacherDAO.TeacherGender + " is null");
            return this;
        }
        public Criteria andTeacherGenderIsNotNull() {
            addCriterion(ITeacherDAO.TeacherGender + " is not null");
            return this;
        }
    
        public Criteria andTeacherGenderIsNotEmpty() {        
            addCriterion(ITeacherDAO.TeacherGender + " is not null AND " + ITeacherDAO.TeacherGender + " <> ''");
            return this;
        }
    		
    	public Criteria andTeacherGenderIsEmpty() {       
            addCriterion("(" + ITeacherDAO.TeacherGender + " is null OR " + ITeacherDAO.TeacherGender + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andTeacherGenderEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.TeacherGender + " = ", value, "teacherGender");
            return this;
        }
        
        public Criteria andTeacherGenderEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherGender);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherGenderEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andTeacherGenderNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.TeacherGender + " <>", value, "teacherGender");
            return this;
        }
               
        public Criteria andTeacherGenderNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.TeacherGender + " is null OR " + ITeacherDAO.TeacherGender + " <>", value, "teacherGender");
            return this;
        }
        
        public Criteria andTeacherGenderNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherGender);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherGenderNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherGenderGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.TeacherGender + " >", value, "teacherGender");
            return this;
        }
        
        public Criteria andTeacherGenderGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherGender);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherGenderGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherGenderGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.TeacherGender + " >=", value, "teacherGender");
            return this;
        }
        
        public Criteria andTeacherGenderGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherGender);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherGenderGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherGenderLessThan(String value) {
        				
            addCriterion(ITeacherDAO.TeacherGender + " <", value, "teacherGender");
            return this;
        }
        
        public Criteria andTeacherGenderLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherGender);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherGenderLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherGenderLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.TeacherGender + " <=", value, "teacherGender");
            return this;
        }
        
        public Criteria andTeacherGenderLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherGender);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherGenderLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andTeacherGenderLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.TeacherGender + " like", buffer.toString(), "teacherGender");
            return this;
        }
        public Criteria andTeacherGenderNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.TeacherGender + " not like", buffer.toString(), "teacherGender");
            return this;
        }
                
                public Criteria andTeacherGenderIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andTeacherGenderEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherGender + " in", values, "teacherGender");
            	return this;
            }
        }
        public Criteria andTeacherGenderNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andTeacherGenderNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherGender + " not in", values, "teacherGender");
            	return this;
            }
        }
        
        public Criteria andTeacherGenderIn(String[] values) {
        	
        	if(values.length == 1){
        		return andTeacherGenderEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherGender + " in", Arrays.asList(values), "teacherGender");
            	return this;
            }
        }
        public Criteria andTeacherGenderNotIn(String[] values) {
        	if(values.length == 1){
        		return andTeacherGenderNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.TeacherGender + " not in", Arrays.asList(values), "teacherGender");
            	return this;
            }
        }
		
		public Criteria andTeacherGenderIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andTeacherGenderNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherGender + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherGenderBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.TeacherGender + " between", value1, value2, "teacherGender");
            return this;
        }
        
                public Criteria andTeacherGenderNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.TeacherGender + " not between", value1, value2, "teacherGender");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andTeacherBirthdayIsNull() {
            addCriterion(ITeacherDAO.TeacherBirthday + " is null");
            return this;
        }
        public Criteria andTeacherBirthdayIsNotNull() {
            addCriterion(ITeacherDAO.TeacherBirthday + " is not null");
            return this;
        }
    
        public Criteria andTeacherBirthdayIsNotEmpty() {        
            addCriterion(ITeacherDAO.TeacherBirthday + " is not null AND " + ITeacherDAO.TeacherBirthday + " <> ''");
            return this;
        }
    		
    	public Criteria andTeacherBirthdayIsEmpty() {       
            addCriterion("(" + ITeacherDAO.TeacherBirthday + " is null OR " + ITeacherDAO.TeacherBirthday + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andTeacherBirthdayEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " = ", value, "teacherBirthday");
            return this;
        }
        
        public Criteria andTeacherBirthdayEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherBirthday);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherBirthdayEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andTeacherBirthdayNotEqualTo(java.util.Date value) {
        	        
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " <>", value, "teacherBirthday");
            return this;
        }
               
        public Criteria andTeacherBirthdayNotEqualToOrIsNull(java.util.Date value) {
        	        
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " is null OR " + ITeacherDAO.TeacherBirthday + " <>", value, "teacherBirthday");
            return this;
        }
        
        public Criteria andTeacherBirthdayNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherBirthday);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherBirthdayNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherBirthdayGreaterThan(java.util.Date value) {
        				
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " >", value, "teacherBirthday");
            return this;
        }
        
        public Criteria andTeacherBirthdayGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.TeacherBirthday);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherBirthdayGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherBirthdayGreaterThanOrEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " >=", value, "teacherBirthday");
            return this;
        }
        
        public Criteria andTeacherBirthdayGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherBirthday);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherBirthdayGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherBirthdayLessThan(java.util.Date value) {
        				
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " <", value, "teacherBirthday");
            return this;
        }
        
        public Criteria andTeacherBirthdayLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherBirthday);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherBirthdayLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherBirthdayLessThanOrEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " <=", value, "teacherBirthday");
            return this;
        }
        
        public Criteria andTeacherBirthdayLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.TeacherBirthday);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherBirthdayLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                public Criteria andTeacherBirthdayIn(List<java.util.Date> values) {
        	
        	if(values.size() == 1){
        		return andTeacherBirthdayEqualTo(values.get(0));
        	}
        	else{
            	addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " in", values, "teacherBirthday");
            	return this;
            }
        }
        public Criteria andTeacherBirthdayNotIn(List<java.util.Date> values) {
        	if(values.size() == 1){
        		return andTeacherBirthdayNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " not in", values, "teacherBirthday");
            	return this;
            }
        }
        
        public Criteria andTeacherBirthdayIn(java.util.Date[] values) {
        	
        	if(values.length == 1){
        		return andTeacherBirthdayEqualTo(values[0]);
        	}
        	else{
            	addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " in", Arrays.asList(values), "teacherBirthday");
            	return this;
            }
        }
        public Criteria andTeacherBirthdayNotIn(java.util.Date[] values) {
        	if(values.length == 1){
        		return andTeacherBirthdayNotEqualTo(values[0]);
        	}
        	else{
            	addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " not in", Arrays.asList(values), "teacherBirthday");
            	return this;
            }
        }
		
		public Criteria andTeacherBirthdayIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andTeacherBirthdayNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.TeacherBirthday + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherBirthdayBetween(java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " between", value1, value2, "teacherBirthday");
            return this;
        }
        
                public Criteria andTeacherBirthdayNotBetween(java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(ITeacherDAO.TeacherBirthday + " not between", value1, value2, "teacherBirthday");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andContactPhoneIsNull() {
            addCriterion(ITeacherDAO.ContactPhone + " is null");
            return this;
        }
        public Criteria andContactPhoneIsNotNull() {
            addCriterion(ITeacherDAO.ContactPhone + " is not null");
            return this;
        }
    
        public Criteria andContactPhoneIsNotEmpty() {        
            addCriterion(ITeacherDAO.ContactPhone + " is not null AND " + ITeacherDAO.ContactPhone + " <> ''");
            return this;
        }
    		
    	public Criteria andContactPhoneIsEmpty() {       
            addCriterion("(" + ITeacherDAO.ContactPhone + " is null OR " + ITeacherDAO.ContactPhone + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andContactPhoneEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.ContactPhone + " = ", value, "contactPhone");
            return this;
        }
        
        public Criteria andContactPhoneEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.ContactPhone);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactPhoneEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andContactPhoneNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.ContactPhone + " <>", value, "contactPhone");
            return this;
        }
               
        public Criteria andContactPhoneNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.ContactPhone + " is null OR " + ITeacherDAO.ContactPhone + " <>", value, "contactPhone");
            return this;
        }
        
        public Criteria andContactPhoneNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.ContactPhone);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactPhoneNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andContactPhoneGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.ContactPhone + " >", value, "contactPhone");
            return this;
        }
        
        public Criteria andContactPhoneGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.ContactPhone);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactPhoneGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andContactPhoneGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.ContactPhone + " >=", value, "contactPhone");
            return this;
        }
        
        public Criteria andContactPhoneGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.ContactPhone);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactPhoneGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andContactPhoneLessThan(String value) {
        				
            addCriterion(ITeacherDAO.ContactPhone + " <", value, "contactPhone");
            return this;
        }
        
        public Criteria andContactPhoneLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.ContactPhone);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactPhoneLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andContactPhoneLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.ContactPhone + " <=", value, "contactPhone");
            return this;
        }
        
        public Criteria andContactPhoneLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.ContactPhone);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactPhoneLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andContactPhoneLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.ContactPhone + " like", buffer.toString(), "contactPhone");
            return this;
        }
        public Criteria andContactPhoneNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.ContactPhone + " not like", buffer.toString(), "contactPhone");
            return this;
        }
                
                public Criteria andContactPhoneIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andContactPhoneEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactPhone + " in", values, "contactPhone");
            	return this;
            }
        }
        public Criteria andContactPhoneNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andContactPhoneNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactPhone + " not in", values, "contactPhone");
            	return this;
            }
        }
        
        public Criteria andContactPhoneIn(String[] values) {
        	
        	if(values.length == 1){
        		return andContactPhoneEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactPhone + " in", Arrays.asList(values), "contactPhone");
            	return this;
            }
        }
        public Criteria andContactPhoneNotIn(String[] values) {
        	if(values.length == 1){
        		return andContactPhoneNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactPhone + " not in", Arrays.asList(values), "contactPhone");
            	return this;
            }
        }
		
		public Criteria andContactPhoneIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andContactPhoneNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactPhone + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andContactPhoneBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.ContactPhone + " between", value1, value2, "contactPhone");
            return this;
        }
        
                public Criteria andContactPhoneNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.ContactPhone + " not between", value1, value2, "contactPhone");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andContactsRelationIsNull() {
            addCriterion(ITeacherDAO.ContactsRelation + " is null");
            return this;
        }
        public Criteria andContactsRelationIsNotNull() {
            addCriterion(ITeacherDAO.ContactsRelation + " is not null");
            return this;
        }
    
        public Criteria andContactsRelationIsNotEmpty() {        
            addCriterion(ITeacherDAO.ContactsRelation + " is not null AND " + ITeacherDAO.ContactsRelation + " <> ''");
            return this;
        }
    		
    	public Criteria andContactsRelationIsEmpty() {       
            addCriterion("(" + ITeacherDAO.ContactsRelation + " is null OR " + ITeacherDAO.ContactsRelation + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andContactsRelationEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.ContactsRelation + " = ", value, "contactsRelation");
            return this;
        }
        
        public Criteria andContactsRelationEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.ContactsRelation);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactsRelationEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andContactsRelationNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.ContactsRelation + " <>", value, "contactsRelation");
            return this;
        }
               
        public Criteria andContactsRelationNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.ContactsRelation + " is null OR " + ITeacherDAO.ContactsRelation + " <>", value, "contactsRelation");
            return this;
        }
        
        public Criteria andContactsRelationNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.ContactsRelation);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactsRelationNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andContactsRelationGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.ContactsRelation + " >", value, "contactsRelation");
            return this;
        }
        
        public Criteria andContactsRelationGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.ContactsRelation);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactsRelationGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andContactsRelationGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.ContactsRelation + " >=", value, "contactsRelation");
            return this;
        }
        
        public Criteria andContactsRelationGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.ContactsRelation);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactsRelationGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andContactsRelationLessThan(String value) {
        				
            addCriterion(ITeacherDAO.ContactsRelation + " <", value, "contactsRelation");
            return this;
        }
        
        public Criteria andContactsRelationLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.ContactsRelation);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactsRelationLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andContactsRelationLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.ContactsRelation + " <=", value, "contactsRelation");
            return this;
        }
        
        public Criteria andContactsRelationLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.ContactsRelation);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andContactsRelationLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andContactsRelationLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.ContactsRelation + " like", buffer.toString(), "contactsRelation");
            return this;
        }
        public Criteria andContactsRelationNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.ContactsRelation + " not like", buffer.toString(), "contactsRelation");
            return this;
        }
                
                public Criteria andContactsRelationIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andContactsRelationEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactsRelation + " in", values, "contactsRelation");
            	return this;
            }
        }
        public Criteria andContactsRelationNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andContactsRelationNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactsRelation + " not in", values, "contactsRelation");
            	return this;
            }
        }
        
        public Criteria andContactsRelationIn(String[] values) {
        	
        	if(values.length == 1){
        		return andContactsRelationEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactsRelation + " in", Arrays.asList(values), "contactsRelation");
            	return this;
            }
        }
        public Criteria andContactsRelationNotIn(String[] values) {
        	if(values.length == 1){
        		return andContactsRelationNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.ContactsRelation + " not in", Arrays.asList(values), "contactsRelation");
            	return this;
            }
        }
		
		public Criteria andContactsRelationIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andContactsRelationNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.ContactsRelation + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andContactsRelationBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.ContactsRelation + " between", value1, value2, "contactsRelation");
            return this;
        }
        
                public Criteria andContactsRelationNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.ContactsRelation + " not between", value1, value2, "contactsRelation");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andIdCardTypeIsNull() {
            addCriterion(ITeacherDAO.IdCardType + " is null");
            return this;
        }
        public Criteria andIdCardTypeIsNotNull() {
            addCriterion(ITeacherDAO.IdCardType + " is not null");
            return this;
        }
    
        public Criteria andIdCardTypeIsNotEmpty() {        
            addCriterion(ITeacherDAO.IdCardType + " is not null AND " + ITeacherDAO.IdCardType + " <> ''");
            return this;
        }
    		
    	public Criteria andIdCardTypeIsEmpty() {       
            addCriterion("(" + ITeacherDAO.IdCardType + " is null OR " + ITeacherDAO.IdCardType + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andIdCardTypeEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.IdCardType + " = ", value, "idCardType");
            return this;
        }
        
        public Criteria andIdCardTypeEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.IdCardType);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardTypeEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andIdCardTypeNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.IdCardType + " <>", value, "idCardType");
            return this;
        }
               
        public Criteria andIdCardTypeNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.IdCardType + " is null OR " + ITeacherDAO.IdCardType + " <>", value, "idCardType");
            return this;
        }
        
        public Criteria andIdCardTypeNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.IdCardType);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardTypeNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andIdCardTypeGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.IdCardType + " >", value, "idCardType");
            return this;
        }
        
        public Criteria andIdCardTypeGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.IdCardType);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardTypeGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andIdCardTypeGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.IdCardType + " >=", value, "idCardType");
            return this;
        }
        
        public Criteria andIdCardTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.IdCardType);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardTypeGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andIdCardTypeLessThan(String value) {
        				
            addCriterion(ITeacherDAO.IdCardType + " <", value, "idCardType");
            return this;
        }
        
        public Criteria andIdCardTypeLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.IdCardType);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardTypeLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andIdCardTypeLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.IdCardType + " <=", value, "idCardType");
            return this;
        }
        
        public Criteria andIdCardTypeLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.IdCardType);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardTypeLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andIdCardTypeLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.IdCardType + " like", buffer.toString(), "idCardType");
            return this;
        }
        public Criteria andIdCardTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.IdCardType + " not like", buffer.toString(), "idCardType");
            return this;
        }
                
                public Criteria andIdCardTypeIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andIdCardTypeEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardType + " in", values, "idCardType");
            	return this;
            }
        }
        public Criteria andIdCardTypeNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andIdCardTypeNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardType + " not in", values, "idCardType");
            	return this;
            }
        }
        
        public Criteria andIdCardTypeIn(String[] values) {
        	
        	if(values.length == 1){
        		return andIdCardTypeEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardType + " in", Arrays.asList(values), "idCardType");
            	return this;
            }
        }
        public Criteria andIdCardTypeNotIn(String[] values) {
        	if(values.length == 1){
        		return andIdCardTypeNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardType + " not in", Arrays.asList(values), "idCardType");
            	return this;
            }
        }
		
		public Criteria andIdCardTypeIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andIdCardTypeNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardType + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andIdCardTypeBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.IdCardType + " between", value1, value2, "idCardType");
            return this;
        }
        
                public Criteria andIdCardTypeNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.IdCardType + " not between", value1, value2, "idCardType");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andIdCardNumIsNull() {
            addCriterion(ITeacherDAO.IdCardNum + " is null");
            return this;
        }
        public Criteria andIdCardNumIsNotNull() {
            addCriterion(ITeacherDAO.IdCardNum + " is not null");
            return this;
        }
    
        public Criteria andIdCardNumIsNotEmpty() {        
            addCriterion(ITeacherDAO.IdCardNum + " is not null AND " + ITeacherDAO.IdCardNum + " <> ''");
            return this;
        }
    		
    	public Criteria andIdCardNumIsEmpty() {       
            addCriterion("(" + ITeacherDAO.IdCardNum + " is null OR " + ITeacherDAO.IdCardNum + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andIdCardNumEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.IdCardNum + " = ", value, "idCardNum");
            return this;
        }
        
        public Criteria andIdCardNumEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.IdCardNum);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardNumEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andIdCardNumNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.IdCardNum + " <>", value, "idCardNum");
            return this;
        }
               
        public Criteria andIdCardNumNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.IdCardNum + " is null OR " + ITeacherDAO.IdCardNum + " <>", value, "idCardNum");
            return this;
        }
        
        public Criteria andIdCardNumNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.IdCardNum);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardNumNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andIdCardNumGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.IdCardNum + " >", value, "idCardNum");
            return this;
        }
        
        public Criteria andIdCardNumGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.IdCardNum);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardNumGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andIdCardNumGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.IdCardNum + " >=", value, "idCardNum");
            return this;
        }
        
        public Criteria andIdCardNumGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.IdCardNum);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardNumGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andIdCardNumLessThan(String value) {
        				
            addCriterion(ITeacherDAO.IdCardNum + " <", value, "idCardNum");
            return this;
        }
        
        public Criteria andIdCardNumLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.IdCardNum);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardNumLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andIdCardNumLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.IdCardNum + " <=", value, "idCardNum");
            return this;
        }
        
        public Criteria andIdCardNumLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.IdCardNum);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdCardNumLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andIdCardNumLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.IdCardNum + " like", buffer.toString(), "idCardNum");
            return this;
        }
        public Criteria andIdCardNumNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.IdCardNum + " not like", buffer.toString(), "idCardNum");
            return this;
        }
                
                public Criteria andIdCardNumIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andIdCardNumEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardNum + " in", values, "idCardNum");
            	return this;
            }
        }
        public Criteria andIdCardNumNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andIdCardNumNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardNum + " not in", values, "idCardNum");
            	return this;
            }
        }
        
        public Criteria andIdCardNumIn(String[] values) {
        	
        	if(values.length == 1){
        		return andIdCardNumEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardNum + " in", Arrays.asList(values), "idCardNum");
            	return this;
            }
        }
        public Criteria andIdCardNumNotIn(String[] values) {
        	if(values.length == 1){
        		return andIdCardNumNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.IdCardNum + " not in", Arrays.asList(values), "idCardNum");
            	return this;
            }
        }
		
		public Criteria andIdCardNumIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andIdCardNumNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.IdCardNum + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andIdCardNumBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.IdCardNum + " between", value1, value2, "idCardNum");
            return this;
        }
        
                public Criteria andIdCardNumNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.IdCardNum + " not between", value1, value2, "idCardNum");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andSysAccountIdIsNull() {
            addCriterion(ITeacherDAO.SysAccountId + " is null");
            return this;
        }
        public Criteria andSysAccountIdIsNotNull() {
            addCriterion(ITeacherDAO.SysAccountId + " is not null");
            return this;
        }
    
        public Criteria andSysAccountIdIsNotEmpty() {        
            addCriterion(ITeacherDAO.SysAccountId + " is not null AND " + ITeacherDAO.SysAccountId + " <> ''");
            return this;
        }
    		
    	public Criteria andSysAccountIdIsEmpty() {       
            addCriterion("(" + ITeacherDAO.SysAccountId + " is null OR " + ITeacherDAO.SysAccountId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andSysAccountIdEqualTo(long value) {
        	return andSysAccountIdEqualTo(Long.valueOf(value));
        }
               public Criteria andSysAccountIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.SysAccountId + " = ", value, "sysAccountId");
            return this;
        }
        
        public Criteria andSysAccountIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.SysAccountId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSysAccountIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andSysAccountIdNotEqualTo(long value) {
        	return andSysAccountIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andSysAccountIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ITeacherDAO.SysAccountId + " <>", value, "sysAccountId");
            return this;
        }
               
        public Criteria andSysAccountIdNotEqualToOrIsNull(long value) {
        	return andSysAccountIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andSysAccountIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ITeacherDAO.SysAccountId + " is null OR " + ITeacherDAO.SysAccountId + " <>", value, "sysAccountId");
            return this;
        }
        
        public Criteria andSysAccountIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.SysAccountId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSysAccountIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andSysAccountIdGreaterThan(long value) {
        	return andSysAccountIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andSysAccountIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.SysAccountId + " >", value, "sysAccountId");
            return this;
        }
        
        public Criteria andSysAccountIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.SysAccountId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSysAccountIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andSysAccountIdGreaterThanOrEqualTo(long value) {
        	return andSysAccountIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andSysAccountIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.SysAccountId + " >=", value, "sysAccountId");
            return this;
        }
        
        public Criteria andSysAccountIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.SysAccountId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSysAccountIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andSysAccountIdLessThan(long value) {
        	return andSysAccountIdLessThan(Long.valueOf(value));
        }
                public Criteria andSysAccountIdLessThan(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.SysAccountId + " <", value, "sysAccountId");
            return this;
        }
        
        public Criteria andSysAccountIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.SysAccountId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSysAccountIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andSysAccountIdLessThanOrEqualTo(long value) {
        	return andSysAccountIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andSysAccountIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ITeacherDAO.SysAccountId + " <=", value, "sysAccountId");
            return this;
        }
        
        public Criteria andSysAccountIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.SysAccountId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andSysAccountIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andSysAccountIdIn(long[] values) {
        	if(values.length == 1){
        		return andSysAccountIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.SysAccountId + " in", values, "sysAccountId");
            	return this;
            }
        }
        
        public Criteria andSysAccountIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andSysAccountIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.SysAccountId + " not in", values, "sysAccountId");
            	return this;
            }
        }
        
                public Criteria andSysAccountIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andSysAccountIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.SysAccountId + " in", values, "sysAccountId");
            	return this;
            }
        }
        public Criteria andSysAccountIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andSysAccountIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.SysAccountId + " not in", values, "sysAccountId");
            	return this;
            }
        }
        
        public Criteria andSysAccountIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andSysAccountIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.SysAccountId + " in", Arrays.asList(values), "sysAccountId");
            	return this;
            }
        }
        public Criteria andSysAccountIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andSysAccountIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.SysAccountId + " not in", Arrays.asList(values), "sysAccountId");
            	return this;
            }
        }
		
		public Criteria andSysAccountIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andSysAccountIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.SysAccountId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andSysAccountIdBetween(long value1,long value2) {
        	addCriterion(ITeacherDAO.SysAccountId + " between", value1, value2, "sysAccountId");
            return this;
        }
                public Criteria andSysAccountIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ITeacherDAO.SysAccountId + " between", value1, value2, "sysAccountId");
            return this;
        }
        
                
        public Criteria andSysAccountIdNotBetween(long value1,long value2) {
        	addCriterion(ITeacherDAO.SysAccountId + " not between", value1, value2, "sysAccountId");
            return this;
        }
                public Criteria andSysAccountIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ITeacherDAO.SysAccountId + " not between", value1, value2, "sysAccountId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andDeleteFlagIsNull() {
            addCriterion(ITeacherDAO.DeleteFlag + " is null");
            return this;
        }
        public Criteria andDeleteFlagIsNotNull() {
            addCriterion(ITeacherDAO.DeleteFlag + " is not null");
            return this;
        }
    
        public Criteria andDeleteFlagIsNotEmpty() {        
            addCriterion(ITeacherDAO.DeleteFlag + " is not null AND " + ITeacherDAO.DeleteFlag + " <> ''");
            return this;
        }
    		
    	public Criteria andDeleteFlagIsEmpty() {       
            addCriterion("(" + ITeacherDAO.DeleteFlag + " is null OR " + ITeacherDAO.DeleteFlag + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andDeleteFlagEqualTo(int value) {
        	return andDeleteFlagEqualTo(Integer.valueOf(value));
        }
               public Criteria andDeleteFlagEqualTo(java.lang.Integer value) {
        				
            addCriterion(ITeacherDAO.DeleteFlag + " = ", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.DeleteFlag);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andDeleteFlagNotEqualTo(int value) {
        	return andDeleteFlagNotEqualTo(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagNotEqualTo(java.lang.Integer value) {
        	        
            addCriterion(ITeacherDAO.DeleteFlag + " <>", value, "deleteFlag");
            return this;
        }
               
        public Criteria andDeleteFlagNotEqualToOrIsNull(int value) {
        	return andDeleteFlagNotEqualToOrIsNull(Integer.valueOf(value));
        }
                
        public Criteria andDeleteFlagNotEqualToOrIsNull(java.lang.Integer value) {
        	        
            addCriterion(ITeacherDAO.DeleteFlag + " is null OR " + ITeacherDAO.DeleteFlag + " <>", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.DeleteFlag);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andDeleteFlagGreaterThan(int value) {
        	return andDeleteFlagGreaterThan(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagGreaterThan(java.lang.Integer value) {
        				
            addCriterion(ITeacherDAO.DeleteFlag + " >", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.DeleteFlag);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andDeleteFlagGreaterThanOrEqualTo(int value) {
        	return andDeleteFlagGreaterThanOrEqualTo(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagGreaterThanOrEqualTo(java.lang.Integer value) {
        				
            addCriterion(ITeacherDAO.DeleteFlag + " >=", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.DeleteFlag);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagLessThan(int value) {
        	return andDeleteFlagLessThan(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagLessThan(java.lang.Integer value) {
        				
            addCriterion(ITeacherDAO.DeleteFlag + " <", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.DeleteFlag);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagLessThanOrEqualTo(int value) {
        	return andDeleteFlagLessThanOrEqualTo(Integer.valueOf(value));
        }
                public Criteria andDeleteFlagLessThanOrEqualTo(java.lang.Integer value) {
        				
            addCriterion(ITeacherDAO.DeleteFlag + " <=", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.DeleteFlag);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andDeleteFlagIn(int[] values) {
        	if(values.length == 1){
        		return andDeleteFlagEqualTo((java.lang.Integer)values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.DeleteFlag + " in", values, "deleteFlag");
            	return this;
            }
        }
        
        public Criteria andDeleteFlagNotIn(int[] values) {
        	if(values.length == 1){
        		return andDeleteFlagNotEqualTo((java.lang.Integer)values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.DeleteFlag + " not in", values, "deleteFlag");
            	return this;
            }
        }
        
                public Criteria andDeleteFlagIn(List<java.lang.Integer> values) {
        	
        	if(values.size() == 1){
        		return andDeleteFlagEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.DeleteFlag + " in", values, "deleteFlag");
            	return this;
            }
        }
        public Criteria andDeleteFlagNotIn(List<java.lang.Integer> values) {
        	if(values.size() == 1){
        		return andDeleteFlagNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.DeleteFlag + " not in", values, "deleteFlag");
            	return this;
            }
        }
        
        public Criteria andDeleteFlagIn(java.lang.Integer[] values) {
        	
        	if(values.length == 1){
        		return andDeleteFlagEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.DeleteFlag + " in", Arrays.asList(values), "deleteFlag");
            	return this;
            }
        }
        public Criteria andDeleteFlagNotIn(java.lang.Integer[] values) {
        	if(values.length == 1){
        		return andDeleteFlagNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.DeleteFlag + " not in", Arrays.asList(values), "deleteFlag");
            	return this;
            }
        }
		
		public Criteria andDeleteFlagIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andDeleteFlagNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.DeleteFlag + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagBetween(int value1,int value2) {
        	addCriterion(ITeacherDAO.DeleteFlag + " between", value1, value2, "deleteFlag");
            return this;
        }
                public Criteria andDeleteFlagBetween(java.lang.Integer value1, java.lang.Integer value2) {
            addCriterion(ITeacherDAO.DeleteFlag + " between", value1, value2, "deleteFlag");
            return this;
        }
        
                
        public Criteria andDeleteFlagNotBetween(int value1,int value2) {
        	addCriterion(ITeacherDAO.DeleteFlag + " not between", value1, value2, "deleteFlag");
            return this;
        }
                public Criteria andDeleteFlagNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
            addCriterion(ITeacherDAO.DeleteFlag + " not between", value1, value2, "deleteFlag");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andStatusIsNull() {
            addCriterion(ITeacherDAO.Status + " is null");
            return this;
        }
        public Criteria andStatusIsNotNull() {
            addCriterion(ITeacherDAO.Status + " is not null");
            return this;
        }
    
        public Criteria andStatusIsNotEmpty() {        
            addCriterion(ITeacherDAO.Status + " is not null AND " + ITeacherDAO.Status + " <> ''");
            return this;
        }
    		
    	public Criteria andStatusIsEmpty() {       
            addCriterion("(" + ITeacherDAO.Status + " is null OR " + ITeacherDAO.Status + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andStatusEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.Status + " = ", value, "status");
            return this;
        }
        
        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Status);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andStatusNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.Status + " <>", value, "status");
            return this;
        }
               
        public Criteria andStatusNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.Status + " is null OR " + ITeacherDAO.Status + " <>", value, "status");
            return this;
        }
        
        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Status);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andStatusGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.Status + " >", value, "status");
            return this;
        }
        
        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Status);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andStatusGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.Status + " >=", value, "status");
            return this;
        }
        
        public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Status);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusLessThan(String value) {
        				
            addCriterion(ITeacherDAO.Status + " <", value, "status");
            return this;
        }
        
        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Status);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.Status + " <=", value, "status");
            return this;
        }
        
        public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Status);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andStatusLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.Status + " like", buffer.toString(), "status");
            return this;
        }
        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.Status + " not like", buffer.toString(), "status");
            return this;
        }
                
                public Criteria andStatusIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andStatusEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.Status + " in", values, "status");
            	return this;
            }
        }
        public Criteria andStatusNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andStatusNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.Status + " not in", values, "status");
            	return this;
            }
        }
        
        public Criteria andStatusIn(String[] values) {
        	
        	if(values.length == 1){
        		return andStatusEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Status + " in", Arrays.asList(values), "status");
            	return this;
            }
        }
        public Criteria andStatusNotIn(String[] values) {
        	if(values.length == 1){
        		return andStatusNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Status + " not in", Arrays.asList(values), "status");
            	return this;
            }
        }
		
		public Criteria andStatusIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Status + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.Status + " between", value1, value2, "status");
            return this;
        }
        
                public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.Status + " not between", value1, value2, "status");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andRemarksIsNull() {
            addCriterion(ITeacherDAO.Remarks + " is null");
            return this;
        }
        public Criteria andRemarksIsNotNull() {
            addCriterion(ITeacherDAO.Remarks + " is not null");
            return this;
        }
    
        public Criteria andRemarksIsNotEmpty() {        
            addCriterion(ITeacherDAO.Remarks + " is not null AND " + ITeacherDAO.Remarks + " <> ''");
            return this;
        }
    		
    	public Criteria andRemarksIsEmpty() {       
            addCriterion("(" + ITeacherDAO.Remarks + " is null OR " + ITeacherDAO.Remarks + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andRemarksEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.Remarks + " = ", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Remarks);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andRemarksNotEqualTo(String value) {
        	        
            addCriterion(ITeacherDAO.Remarks + " <>", value, "remarks");
            return this;
        }
               
        public Criteria andRemarksNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ITeacherDAO.Remarks + " is null OR " + ITeacherDAO.Remarks + " <>", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Remarks);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andRemarksGreaterThan(String value) {
        				
            addCriterion(ITeacherDAO.Remarks + " >", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ITeacherDAO.Remarks);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andRemarksGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.Remarks + " >=", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Remarks);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksLessThan(String value) {
        				
            addCriterion(ITeacherDAO.Remarks + " <", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Remarks);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksLessThanOrEqualTo(String value) {
        				
            addCriterion(ITeacherDAO.Remarks + " <=", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ITeacherDAO.Remarks);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andRemarksLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.Remarks + " like", buffer.toString(), "remarks");
            return this;
        }
        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ITeacherDAO.Remarks + " not like", buffer.toString(), "remarks");
            return this;
        }
                
                public Criteria andRemarksIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andRemarksEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.Remarks + " in", values, "remarks");
            	return this;
            }
        }
        public Criteria andRemarksNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andRemarksNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ITeacherDAO.Remarks + " not in", values, "remarks");
            	return this;
            }
        }
        
        public Criteria andRemarksIn(String[] values) {
        	
        	if(values.length == 1){
        		return andRemarksEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Remarks + " in", Arrays.asList(values), "remarks");
            	return this;
            }
        }
        public Criteria andRemarksNotIn(String[] values) {
        	if(values.length == 1){
        		return andRemarksNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ITeacherDAO.Remarks + " not in", Arrays.asList(values), "remarks");
            	return this;
            }
        }
		
		public Criteria andRemarksIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ITeacherDAO.Remarks + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.Remarks + " between", value1, value2, "remarks");
            return this;
        }
        
                public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(ITeacherDAO.Remarks + " not between", value1, value2, "remarks");
            return this;
        }
        
            	
    	    	
    	        
        
    }
	
    
}